/*
 * Copyright (c) KylinSoft Co., Ltd. 2016-2024.All rights reserved.
 *
 * Authors:
 * Ma Chao    machao@kylinos.cn
 * Alan Xie   xiehuijun@kylinos.cn
 * Clom       huangcailong@kylinos.cn
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/*
 *	This file was automatically generated by dbusxx-xml2cpp; DO NOT EDIT!
 */

#ifndef __dbusxx__kmre_server_glue_h__ADAPTOR_MARSHAL_H
#define __dbusxx__kmre_server_glue_h__ADAPTOR_MARSHAL_H

#include <dbus-c++/dbus.h>
#include <cassert>

namespace kmre {
extern std::string dbusCallSender;
}

namespace cn {
namespace kylinos {

class Kmre_adaptor
: public ::DBus::InterfaceAdaptor
{
public:

    Kmre_adaptor()
    : ::DBus::InterfaceAdaptor("cn.kylinos.Kmre")
    {
        register_method(Kmre_adaptor, Prepare, _Prepare_stub);
        register_method(Kmre_adaptor, StartContainer, _StartContainer_stub);
        register_method(Kmre_adaptor, StartContainerSilently, _StartContainerSilently_stub);
        register_method(Kmre_adaptor, ChangeContainerRuntimeStatus, _ChangeContainerRuntimeStatus_stub);
        register_method(Kmre_adaptor, StopContainer, _StopContainer_stub);
        register_method(Kmre_adaptor, SetFocusOnContainer, _SetFocusOnContainer_stub);
        register_method(Kmre_adaptor, SetPropOfContainer, _SetPropOfContainer_stub);
        register_method(Kmre_adaptor, GetPropOfContainer, _GetPropOfContainer_stub);
        register_method(Kmre_adaptor, SetDefaultPropOfContainer, _SetDefaultPropOfContainer_stub);
        register_method(Kmre_adaptor, GetDefaultPropOfContainer, _GetDefaultPropOfContainer_stub);
        register_method(Kmre_adaptor, GetContainerNetworkInformation, _GetContainerNetworkInformation_stub);
        register_method(Kmre_adaptor, SetGlobalEnvironmentVariable, _SetGlobalEnvironmentVariable_stub);
        register_method(Kmre_adaptor, LoadImage, _LoadImage_stub);
        register_method(Kmre_adaptor, IsImageReady, _IsImageReady_stub);
        register_method(Kmre_adaptor, GetAllContainersAndImages, _GetAllContainersAndImages_stub);
        register_method(Kmre_adaptor, SwitchImage, _SwitchImage_stub);
        register_method(Kmre_adaptor, RemoveOneContainer, _RemoveOneContainer_stub);
        register_method(Kmre_adaptor, RemoveOneImage, _RemoveOneImage_stub);
        register_method(Kmre_adaptor, ComponentsUpgrade, _ComponentsUpgrade_stub);
    }

    ::DBus::IntrospectedInterface *introspect() const 
    {
        static ::DBus::IntrospectedArgument Prepare_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "ret", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument StartContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "width", "i", true },
            { "height", "i", true },
            { "ret", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument StartContainerSilently_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "ret", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ChangeContainerRuntimeStatus_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "ret", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument StopContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "ret", "i", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument SetFocusOnContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "onFocus", "i", true },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument SetPropOfContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "prop", "s", true },
            { "value", "s", true },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument GetPropOfContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "prop", "s", true },
            { "value", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument SetDefaultPropOfContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "prop", "s", true },
            { "value", "s", true },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument GetDefaultPropOfContainer_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "prop", "s", true },
            { "value", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument GetContainerNetworkInformation_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "info", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument SetGlobalEnvironmentVariable_args[] = 
        {
            { "key", "s", true },
            { "value", "s", true },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument LoadImage_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument IsImageReady_args[] = 
        {
            { "ready", "u", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument GetAllContainersAndImages_args[] = 
        {
            { "user", "s", true },
            { "uid", "i", true },
            { "value", "a{ss}", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument SwitchImage_args[] = 
        {
            { "repo", "s", true },
            { "tag", "s", true },
            { "ret", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument RemoveOneContainer_args[] = 
        {
            { "container", "s", true },
            { "ret", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument RemoveOneImage_args[] = 
        {
            { "container", "s", true },
            { "image", "s", true },
            { "ret", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ComponentsUpgrade_args[] = 
        {
            { "args", "s", true },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ComponentsUpgradeFinished_args[] = 
        {
            { "args", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument Stopped_args[] = 
        {
            { "container", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument Started_args[] = 
        {
            { "container", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ImageLoaded_args[] = 
        {
            { "loaded", "u", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ContainerRemoved_args[] = 
        {
            { "container", "s", false },
            { "ret", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ImageRemoved_args[] = 
        {
            { "name", "s", false },
            { "ret", "b", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ServiceStartFailed_args[] = 
        {
            { "name", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ServiceNotFound_args[] = 
        {
            { "name", "s", false },
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ImageConfNotFound_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ImageFileNotFound_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ImageLoadFailed_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedArgument ImageNotMatched_args[] = 
        {
            { 0, 0, 0 }
        };
        static ::DBus::IntrospectedMethod Kmre_adaptor_methods[] = 
        {
            { "Prepare", Prepare_args },
            { "StartContainer", StartContainer_args },
            { "StartContainerSilently", StartContainerSilently_args },
            { "ChangeContainerRuntimeStatus", ChangeContainerRuntimeStatus_args },
            { "StopContainer", StopContainer_args },
            { "SetFocusOnContainer", SetFocusOnContainer_args },
            { "SetPropOfContainer", SetPropOfContainer_args },
            { "GetPropOfContainer", GetPropOfContainer_args },
            { "SetDefaultPropOfContainer", SetDefaultPropOfContainer_args },
            { "GetDefaultPropOfContainer", GetDefaultPropOfContainer_args },
            { "GetContainerNetworkInformation", GetContainerNetworkInformation_args },
            { "SetGlobalEnvironmentVariable", SetGlobalEnvironmentVariable_args },
            { "LoadImage", LoadImage_args },
            { "IsImageReady", IsImageReady_args },
            { "GetAllContainersAndImages", GetAllContainersAndImages_args },
            { "SwitchImage", SwitchImage_args },
            { "RemoveOneContainer", RemoveOneContainer_args },
            { "RemoveOneImage", RemoveOneImage_args },
            { "ComponentsUpgrade", ComponentsUpgrade_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedMethod Kmre_adaptor_signals[] = 
        {
            { "ComponentsUpgradeFinished", ComponentsUpgradeFinished_args },
            { "Stopped", Stopped_args },
            { "Started", Started_args },
            { "ImageLoaded", ImageLoaded_args },
            { "ContainerRemoved", ContainerRemoved_args },
            { "ImageRemoved", ImageRemoved_args },
            { "ServiceStartFailed", ServiceStartFailed_args },
            { "ServiceNotFound", ServiceNotFound_args },
            { "ImageConfNotFound", ImageConfNotFound_args },
            { "ImageFileNotFound", ImageFileNotFound_args },
            { "ImageLoadFailed", ImageLoadFailed_args },
            { "ImageNotMatched", ImageNotMatched_args },
            { 0, 0 }
        };
        static ::DBus::IntrospectedProperty Kmre_adaptor_properties[] = 
        {
            { 0, 0, 0, 0 }
        };
        static ::DBus::IntrospectedInterface Kmre_adaptor_interface = 
        {
            "cn.kylinos.Kmre",
            Kmre_adaptor_methods,
            Kmre_adaptor_signals,
            Kmre_adaptor_properties
        };
        return &Kmre_adaptor_interface;
    }

public:

    /* properties exposed by this interface, use
     * property() and property(value) to get and set a particular property
     */

public:

    /* methods exported by this interface,
     * you will have to implement them in your ObjectAdaptor
     */
    virtual int32_t Prepare(const std::string& user, const int32_t& uid) = 0;
    virtual int32_t StartContainer(const std::string& user, const int32_t& uid, const int32_t& width, const int32_t& height) = 0;
    virtual int32_t StartContainerSilently(const std::string& user, const int32_t& uid) = 0;
    virtual int32_t ChangeContainerRuntimeStatus(const std::string& user, const int32_t& uid) = 0;
    virtual int32_t StopContainer(const std::string& user, const int32_t& uid) = 0;
    virtual void SetFocusOnContainer(const std::string& user, const int32_t& uid, const int32_t& onFocus) = 0;
    virtual void SetPropOfContainer(const std::string& user, const int32_t& uid, const std::string& prop, const std::string& value) = 0;
    virtual std::string GetPropOfContainer(const std::string& user, const int32_t& uid, const std::string& prop) = 0;
    virtual void SetDefaultPropOfContainer(const std::string& user, const int32_t& uid, const std::string& prop, const std::string& value) = 0;
    virtual std::string GetDefaultPropOfContainer(const std::string& user, const int32_t& uid, const std::string& prop) = 0;
    virtual std::string GetContainerNetworkInformation(const std::string& user, const int32_t& uid) = 0;
    virtual void SetGlobalEnvironmentVariable(const std::string& key, const std::string& value) = 0;
    virtual void LoadImage() = 0;
    virtual uint32_t IsImageReady() = 0;
    virtual std::map< std::string, std::string > GetAllContainersAndImages(const std::string& user, const int32_t& uid) = 0;
    virtual bool SwitchImage(const std::string& repo, const std::string& tag) = 0;
    virtual bool RemoveOneContainer(const std::string& container) = 0;
    virtual bool RemoveOneImage(const std::string& container, const std::string& image) = 0;
    virtual void ComponentsUpgrade(const std::string& args) = 0;

public:

    /* signal emitters for this interface
     */
    void ComponentsUpgradeFinished(const std::string& arg1)
    {
        ::DBus::SignalMessage sig("ComponentsUpgradeFinished");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        emit_signal(sig);
    }
    void Stopped(const std::string& arg1)
    {
        ::DBus::SignalMessage sig("Stopped");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        emit_signal(sig);
    }
    void Started(const std::string& arg1)
    {
        ::DBus::SignalMessage sig("Started");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        emit_signal(sig);
    }
    void ImageLoaded(const uint32_t& arg1)
    {
        ::DBus::SignalMessage sig("ImageLoaded");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        emit_signal(sig);
    }
    void ContainerRemoved(const std::string& arg1, const bool& arg2)
    {
        ::DBus::SignalMessage sig("ContainerRemoved");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        wi << arg2;
        emit_signal(sig);
    }
    void ImageRemoved(const std::string& arg1, const bool& arg2)
    {
        ::DBus::SignalMessage sig("ImageRemoved");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        wi << arg2;
        emit_signal(sig);
    }
    void ServiceStartFailed(const std::string& arg1)
    {
        ::DBus::SignalMessage sig("ServiceStartFailed");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        emit_signal(sig);
    }
    void ServiceNotFound(const std::string& arg1)
    {
        ::DBus::SignalMessage sig("ServiceNotFound");
        ::DBus::MessageIter wi = sig.writer();
        wi << arg1;
        emit_signal(sig);
    }
    void ImageConfNotFound()
    {
        ::DBus::SignalMessage sig("ImageConfNotFound");
        emit_signal(sig);
    }
    void ImageFileNotFound()
    {
        ::DBus::SignalMessage sig("ImageFileNotFound");
        emit_signal(sig);
    }
    void ImageLoadFailed()
    {
        ::DBus::SignalMessage sig("ImageLoadFailed");
        emit_signal(sig);
    }
    void ImageNotMatched()
    {
        ::DBus::SignalMessage sig("ImageNotMatched");
        emit_signal(sig);
    }

private:

    /* unmarshalers (to unpack the DBus message before calling the actual interface method)
     */
    ::DBus::Message _Prepare_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argout1 = Prepare(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _StartContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argin3; ri >> argin3;
        int32_t argin4; ri >> argin4;
        int32_t argout1 = StartContainer(argin1, argin2, argin3, argin4);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _StartContainerSilently_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argout1 = StartContainerSilently(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _ChangeContainerRuntimeStatus_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argout1 = ChangeContainerRuntimeStatus(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _StopContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argout1 = StopContainer(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _SetFocusOnContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        int32_t argin3; ri >> argin3;
        SetFocusOnContainer(argin1, argin2, argin3);
        ::DBus::ReturnMessage reply(call);

        return reply;
    }
    ::DBus::Message _SetPropOfContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        std::string argin3; ri >> argin3;
        std::string argin4; ri >> argin4;
        SetPropOfContainer(argin1, argin2, argin3, argin4);
        ::DBus::ReturnMessage reply(call);

        return reply;
    }
    ::DBus::Message _GetPropOfContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        std::string argin3; ri >> argin3;
        std::string argout1 = GetPropOfContainer(argin1, argin2, argin3);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _SetDefaultPropOfContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        std::string argin3; ri >> argin3;
        std::string argin4; ri >> argin4;
        SetDefaultPropOfContainer(argin1, argin2, argin3, argin4);
        ::DBus::ReturnMessage reply(call);

        return reply;
    }
    ::DBus::Message _GetDefaultPropOfContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        std::string argin3; ri >> argin3;
        std::string argout1 = GetDefaultPropOfContainer(argin1, argin2, argin3);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _GetContainerNetworkInformation_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        std::string argout1 = GetContainerNetworkInformation(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _SetGlobalEnvironmentVariable_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        SetGlobalEnvironmentVariable(argin1, argin2);
        ::DBus::ReturnMessage reply(call);

        return reply;
    }
    ::DBus::Message _LoadImage_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();        

        LoadImage();
        ::DBus::ReturnMessage reply(call);

        return reply;
    }
    ::DBus::Message _IsImageReady_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();        

        uint32_t argout1 = IsImageReady();
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _GetAllContainersAndImages_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        int32_t argin2; ri >> argin2;
        std::map< std::string, std::string > argout1 = GetAllContainersAndImages(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _SwitchImage_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = SwitchImage(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _RemoveOneContainer_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        bool argout1 = RemoveOneContainer(argin1);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _RemoveOneImage_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();

        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        std::string argin2; ri >> argin2;
        bool argout1 = RemoveOneImage(argin1, argin2);
        ::DBus::ReturnMessage reply(call);
        ::DBus::MessageIter wi = reply.writer();
        wi << argout1;

        return reply;
    }
    ::DBus::Message _ComponentsUpgrade_stub(const ::DBus::CallMessage &call)
    {
        kmre::dbusCallSender = call.sender();
        
        ::DBus::MessageIter ri = call.reader();
        std::string argin1; ri >> argin1;
        ComponentsUpgrade(argin1);
        ::DBus::ReturnMessage reply(call);

        return reply;
    }
};

} } 
#endif //__dbusxx__kmre_server_glue_h__ADAPTOR_MARSHAL_H
